package com.itheima.leetcode.od.b.string;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * <h3>人民币转换</h3>
 * 将阿拉伯数字金额转换为中文大写金额格式，需遵循以下规则：
 * <p>
 * 1、 前缀要求：中文大写金额前必须标明“人民币”字样。
 * <p>
 * 2、 用字规范：使用壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟、万、亿、元、角、分、零、整等字样。
 * <p>
 * 3、 “整”字规则：
 * <p>
 * 金额到“元”为止时，在“元”后写“整”字（如532.00 → “人民币伍佰叁拾贰元整”）。
 * <p>
 * 金额含“角”或“分”时，不写“整”字（如6007.14 → “人民币陆仟零柒元壹角肆分”）。
 * <p>
 * 4、 零的规则：
 * <p>
 * 阿拉伯数字中间有“0”时，中文大写写“零”（如1010.00 → “人民币壹仟零拾元整”）。
 * <p>
 * 连续多个“0”时，只写一个“零”（如6007.14 → “人民币陆仟零柒元壹角肆分”）。
 * <p>
 * 5、 单位缩写规则：
 * <p>
 * 10写作“拾”，100写作“壹佰”（如110.00 → “人民币壹佰拾元整”）。
 * <p>
 * 十万以上数字接“仟”时不加“零”（如30105000.00 → “人民币叁仟零拾万伍仟元整”）。
 * <p>
 * 输入描述：
 * <p>
 * 输入一个double类型数字，表示待转换的金额（0 ≤ 输入 ≤ 1,000,000,000,000）。
 * <p>
 * 输出描述：
 * <p>
 * 输出符合规则的中文大写金额字符串。
 * <p>
 * 示例1：
 * <p>
 * 输入：
 * <p>
 * 532.00
 * <p>
 * 输出：
 * <p>
 * 人民币伍佰叁拾贰元整
 * <p>
 * 说明：
 * <p>
 * 532的整数部分转换为“伍佰叁拾贰元”，小数部分是零，所以加上“整”字。
 * <p>
 * 示例2：
 * <p>
 * 输入：
 * <p>
 * 6007.14
 * <p>
 * 输出：
 * <p>
 * 人民币陆仟零柒元壹角肆分
 * <p>
 * 示例3：
 * <p>
 * 输入：
 * <p>
 * 99999.99
 * <p>
 * 输出：
 * <p>
 * 人民币玖万玖仟玖佰玖拾玖元玖角玖分
 */
public class RMBConversion {
    public static void main(String[] args) {
        /*Scanner scanner = new Scanner(System.in);
        try {
            double amount = scanner.nextDouble();
            String result = convertAmountToChinese(amount);
            System.out.println(result);
        } catch (Exception e) {
            System.out.println("请输入有效的数字金额");
        }
        scanner.close();*/

        try {
            double amount = 9000000000010.99;
            System.out.println(convertAmountToChinese(amount));
        } catch (Exception e) {
            System.out.println("请输入有效的数字金额");
        }
    }

    // 中文数字映射
    private static final String[] CHINESE_DIGITS = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

    // 单位映射
    private static final String[] UNITS = {"仟", "佰", "拾", ""};

    private static final String[] BIG_UNITS = {"", "万", "亿", "万亿"};

    /**
     * 将阿拉伯数字金额转换为中文大写金额格式
     *
     * @param amount 待转换的金额
     * @return 中文大写金额字符串
     */
    public static String convertAmountToChinese(double amount) {
        // 格式化金额到两位小数
        DecimalFormat df = new DecimalFormat("0.00");
        String amountStr = df.format(amount);
        String[] parts = amountStr.split("\\.");
        String integerPart = parts[0];
        String decimalPart = parts[1];

        // 转换整数部分
        String integerChinese = convertIntegerPart(integerPart);

        // 构建最终结果
        StringBuilder result = new StringBuilder("人民币");

        if ("零".equals(integerChinese)) {
            result.append("零元");
        } else {
            result.append(integerChinese).append("元");
        }

        // 处理小数部分
        int jiao = Integer.parseInt(decimalPart.substring(0, 1)); // 角
        int fen = Integer.parseInt(decimalPart.substring(1, 2));  // 分

        if (jiao == 0 && fen == 0) {
            result.append("整");
        } else {
            if (jiao != 0) {
                result.append(CHINESE_DIGITS[jiao]).append("角");
            }
            if (fen != 0) {
                result.append(CHINESE_DIGITS[fen]).append("分");
            }
        }

        return result.toString();
    }

    /**
     * 转换整数部分为中文
     *
     * @param numStr 整数字符串
     * @return 中文数字字符串
     */
    private static String convertIntegerPart(String numStr) {
        if (numStr == null || numStr.isEmpty() || "0".equals(numStr)) {
            return "零";
        }

        // 将数字分组，每4位一组
        List<String> groups = new ArrayList<>();
        while (!numStr.isEmpty()) {
            if (numStr.length() > 4) {
                groups.add(0, numStr.substring(numStr.length() - 4));
                numStr = numStr.substring(0, numStr.length() - 4);
            } else {
                groups.add(0, numStr);
                break;
            }
        }

        List<String> result = new ArrayList<>();

        for (int i = 0; i < groups.size(); i++) {
            String group = groups.get(i);
            String groupResult = convertGroup(group);

            // 处理空组的情况（全零组）
            if (groupResult.isEmpty() && i < groups.size() - 1) {
                int unitIndex = groups.size() - i - 1;
                if (unitIndex > 0 && unitIndex < BIG_UNITS.length && !result.isEmpty()) {
                    // 检查后面是否还有非零组
                    boolean hasNonZeroAfter = false;
                    for (int j = i + 1; j < groups.size(); j++) {
                        if (!convertGroup(groups.get(j)).isEmpty()) {
                            hasNonZeroAfter = true;
                            break;
                        }
                    }
                    if (hasNonZeroAfter) {
                        result.add(CHINESE_DIGITS[0]);
                    }
                }
                continue;
            }

            if (!groupResult.isEmpty()) {
                // 检查是否需要在组间添加零
                if (i > 0 && !result.isEmpty()) {
                    String paddedGroup = String.format("%4s", group).replace(' ', '0');
                    if (paddedGroup.charAt(0) == '0' && !"0000".equals(paddedGroup)) {
                        result.add("零");
                    }
                }

                result.add(groupResult);

                // 添加大单位
                int unitIndex = groups.size() - i - 1;
                if (unitIndex > 0 && unitIndex < BIG_UNITS.length) {
                    result.add(BIG_UNITS[unitIndex]);
                }
            }
        }

        String finalResult = String.join("", result);

        // 处理连续的零
        while (finalResult.contains("零零")) {
            finalResult = finalResult.replace("零零", "零");
        }

        // 处理零万、零亿的情况
        finalResult = finalResult.replace("零万", "万");
        finalResult = finalResult.replace("零亿", "亿");

        // 去除末尾的零
        if (finalResult.endsWith("零")) {
            finalResult = finalResult.substring(0, finalResult.length() - 1);
        }

        // 去除开头的零
        if (finalResult.startsWith("零")) {
            finalResult = finalResult.substring(1);
        }

        // 简化"壹拾"为"拾"
        finalResult = finalResult.replace("壹拾万", "拾万");
        finalResult = finalResult.replace("壹拾亿", "拾亿");
        finalResult = finalResult.replace("零壹拾", "零拾");
        if (finalResult.startsWith("壹拾")) {
            finalResult = "拾" + finalResult.substring(2);
        }

        return finalResult.isEmpty() ? "零" : finalResult;
    }

    /**
     * 转换4位数字组
     *
     * @param groupStr 4位数字字符串
     * @return 转换后的中文字符串
     */
    private static String convertGroup(String groupStr) {
        if (groupStr == null || groupStr.isEmpty() || "0000".equals(groupStr)) {
            return "";
        }

        // 补齐到4位
        groupStr = String.format("%4s", groupStr).replace(' ', '0');
        List<String> result = new ArrayList<>();

        for (int i = 0; i < groupStr.length(); i++) {
            int digitVal = Character.getNumericValue(groupStr.charAt(i));
            if (digitVal != 0) {
                result.add(CHINESE_DIGITS[digitVal]);
                if (!UNITS[i].isEmpty()) {
                    result.add(UNITS[i]);
                }
            } else if (!result.isEmpty() && !"零".equals(result.get(result.size() - 1))) {
                result.add("零");
            }
        }

        // 移除末尾的零
        while (!result.isEmpty() && "零".equals(result.get(result.size() - 1))) {
            result.remove(result.size() - 1);
        }

        return String.join("", result);
    }
}